package com.shilupan.jiebaijia.common.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;

public class DateUtils {

	public static final String defaultFormat = "yyyy-MM-dd HH:mm:ss";
	
	public static final String dayFormat = "yyyyMMdd";
	
	public static final String dayFormat2 = "yyyy-MM-dd";
	
	public static final String DATETIME_WITH_T = "yyyy-MM-dd'T'HH:mm:ss";

	public static final long oneDay = 1000 * 3600 * 24;

	public static final SimpleDateFormat formatterYear = new SimpleDateFormat(dayFormat2);

	public static final SimpleDateFormat formatterDay = new SimpleDateFormat(dayFormat);
	/*public static final SimpleDateFormat MONTH_FORMAT = new SimpleDateFormat(
			"yyyyMM");
	
	public static final SimpleDateFormat WSU_DATE_TIME_FORMAT = new SimpleDateFormat(
			"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");*/

	public static final int fields[] = { Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR_OF_DAY,
			Calendar.MINUTE, Calendar.SECOND, Calendar.MILLISECOND };
	/**
	 * Date类型转换为Calendar类型
	 * 
	 * @param date
	 *            日期
	 * @return
	 */
	public static Calendar toCalendar(final Date date) {
		final Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar;
	}
	
	/*public static List<String> getMonths(final String beginDate,
			final String endDate) {
		try {
			final List<String> months = new ArrayList<String>();
			final int monthSpan = getMonthSpan(beginDate, endDate);
			final Date[] sorted = sortDate(beginDate, endDate);
			final Date begin = DateUtils.truncate(sorted[0], Calendar.MONTH);
			for (int i = 0; i <= monthSpan; i++) {
				Date date = DateUtils.addMonths(begin, i);
				String month = MONTH_FORMAT.format(date);
				months.add(month);
			}
			return months;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}*/
	
	public static int getMonthSpan(final String beginDate, final String endDate)
			throws ParseException {
		Date[] sorted = sortDate(beginDate, endDate);

		final Calendar calBegin = Calendar.getInstance();
		calBegin.setTime(sorted[0]);

		final Calendar calEnd = Calendar.getInstance();
		calEnd.setTime(sorted[1]);

		final int beginYear = calBegin.get(Calendar.YEAR);
		final int endYear = calEnd.get(Calendar.YEAR);

		final int beginMon = calBegin.get(Calendar.MONTH);
		final int endMon = calEnd.get(Calendar.MONTH);

		final int monthSpan = (endYear - beginYear) * 12 + endMon - beginMon;
		return monthSpan;
	}
	
	public static Date[] sortDate(final String beginDate, final String endDate)
			throws ParseException {
		final Date begin = parseDate(beginDate,dayFormat);
		final Date end = parseDate(endDate,dayFormat);

		boolean normal = end.getTime() - begin.getTime() > 0;
		final Date big = normal ? end : begin;
		final Date small = normal ? begin : end;

		final Date[] sorted = new Date[2];
		sorted[0] = small;
		sorted[1] = big;

		return sorted;
	}

	/**
	 * 设置日期
	 * 
	 * @param date
	 *            源日期
	 * @param field
	 *            日历域
	 * @param value
	 *            值
	 * @return 设置后的日期
	 */
	public static Date set(final Date date, int field, int value) {
		final Date setDate = date == null ? new Date() : date;
		final Calendar calendar = toCalendar(setDate);
		calendar.set(field, value);
		return calendar.getTime();
	}

	public static int get(final Date date, int field) {
		final Calendar calendar = toCalendar(date);
		return calendar.get(field);
	}
	
	/**
	 * 设置日期毫秒数
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            毫秒数
	 * @return 设置后的日期
	 */
	public static Date setMilliseconds(final Date date, int value) {
		return set(date, Calendar.MILLISECOND, value);
	}

	/**
	 * 设置日期秒数
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            毫秒数
	 * @return 设置后的日期
	 */
	public static Date setSeconds(final Date date, int value) {
		return set(date, Calendar.SECOND, value);
	}

	/**
	 * 设置日期的分钟数
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            分钟数
	 * @return 设置后的日期
	 */
	public static Date setMinutes(final Date date, int value) {
		return set(date, Calendar.MINUTE, value);
	}

	/**
	 * 设置日期的小时数
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            小时数
	 * @return 设置后的日期
	 */
	public static Date setHours(final Date date, int value) {
		return set(date, Calendar.HOUR_OF_DAY, value);
	}

	public static int getHours(final Date date) {
		return get(date, Calendar.HOUR_OF_DAY);
	}
	
	/**
	 * 设置日期的月份中的天数
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            天数
	 * @return 设置后的日期
	 */
	public static Date setDays(final Date date, int value) {
		return set(date, Calendar.DAY_OF_MONTH, value);
	}

	/**
	 * 设置日期的月份
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            月份数
	 * @return 设置后的日期
	 */
	public static Date setMonths(final Date date, int value) {
		return set(date, Calendar.MONTH, value);
	}

	/**
	 * 设置日期的年份
	 * 
	 * @param date
	 *            日期
	 * @param value
	 *            年份
	 * @return 设置后的日期
	 */
	public static Date setYears(final Date date, int value) {
		return set(date, Calendar.YEAR, value);
	}

	/**
	 * 截取日期
	 * 
	 * @param date
	 *            日期
	 *            截取的域
	 * @return 截取后的日期
	 */
	public static Date trunc(final Date date, final int field) {
		Date result = date;
		for (int _field : fields) {
			if (_field >= field) {
				switch (_field) {
				case Calendar.YEAR:
					result = setYears(result, 1970);
					break;
				case Calendar.DAY_OF_MONTH:
					result = setDays(result, 1);
					break;
				default:
					result = set(result, _field, 0);
				}
			}
		}
		return result;
	}

	/**
	 * 使用一组格式化规则，将字符串转换为日期
	 * 
	 * @param text
	 *            待转换为日期类型的字符串
	 * @param patterns
	 *            转换的格式数组，为空则以默认格式转换
	 * @return 日期对象
	 */
	public static Date parseDate(String text, String... patterns) {
		if (text == null || "".equals(text))
			return null;
		if (patterns == null || patterns.length == 0)
			patterns = new String[] { defaultFormat };
		Date result = null;
		for (String pattern : patterns) {
			SimpleDateFormat format = new SimpleDateFormat(pattern);
			try {
				result = format.parse(text);
				return result;
			} catch (Exception e) {
				result = null;
			}
		}
		return null;
	}
	
	public static Date parseDateByPattern(String text, String pattern) {
		if (pattern == null)
			pattern = defaultFormat;
		
		return parseDate(text,pattern);
	}

	/**
	 * 将源日期增加一定量，如加一分钟，加一天，加一个月等等
	 * 
	 * @param date
	 *            源日期
	 * @param field
	 *            日历类（Calendar）定义的域，如：Calendar.SENCOND,Calendar.MINUTES
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date add(final Date date, final int field, final int amount) {
		final Date addDate = date == null ? new Date() : date;
		final Calendar calendar = toCalendar(addDate);
		calendar.add(field, amount);
		return calendar.getTime();
	}

	/**
	 * 日期加（减）amount毫秒
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addMilliseconds(final Date date, final int amount) {
		return add(date, Calendar.MILLISECOND, amount);
	}

	/**
	 * 日期加（减）amount秒
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addSeconds(final Date date, final int amount) {
		return add(date, Calendar.SECOND, amount);
	}

	/**
	 * 日期加（减）amount分钟
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addMinutes(final Date date, final int amount) {
		return add(date, Calendar.MINUTE, amount);
	}

	/**
	 * 日期加（减）amount小时
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addHours(final Date date, final int amount) {
		return add(date, Calendar.HOUR_OF_DAY, amount);
	}

	/**
	 * 日期加（减）amount天
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addDays(final Date date, final int amount) {
		return add(date, Calendar.DAY_OF_MONTH, amount);
	}

	/**
	 * 日期加（减）amount月
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addMonths(final Date date, final int amount) {
		return add(date, Calendar.MONTH, amount);
	}

	/**
	 * 日期加（减）amount年
	 * 
	 * @param date
	 *            源日期
	 * @param amount
	 *            增加的数量，可以为负
	 * @return 增加后的日期
	 */
	public static Date addYears(final Date date, final int amount) {
		return add(date, Calendar.YEAR, amount);
	}

	/**
	 * 格式化日期，使用默认格式
	 * 
	 * @param date
	 *            日期
	 * @return 日期字符串
	 */
	public static String fmtDate(Date date) {
		return fmtDate(date, defaultFormat);
	}

	/**
	 * 格式化日期得到字符串
	 * 
	 * @param date
	 *            日期
	 * @param format
	 *            格式
	 * @return 日期字符串
	 */
	public static String fmtDate(Date date, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date);
	}

	/**
	 * 解析字符串得到日期对象
	 * 
	 * @param text
	 *            日期字符串
	 * @param format
	 *            格式
	 * @return 日期对象
	 */
	public static Date getDate(String text, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date date = null;
		try {
			date = sdf.parse(text);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	/**
	 * 使用默认格式，解析字符串得到日期对象
	 * 
	 * @param text
	 *            字符串
	 * @return 日期对象
	 */
	public static Date getDate(String text) {
		if(StringUtil.isNullOrEmpty(text)){
			return null;
		}
		String format = defaultFormat;
		if (text != null && text.length() == 10) {
			format = "yyyy-MM-dd";
		}
		return getDate(text, format);
	}

	/**
	 * 根据毫秒数获取时间
	 * @param time
	 * @return
	 */
	public static Date getDate(long time) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTimeInMillis(time);
		return calendar.getTime();
	}

	/**
	 * 查询月份中第index天，从index从1开始
	 * 
	 * @param month
	 *            月份字符串
	 * @param index
	 *            索引
	 * @return 月份第index天
	 */
	public static Date indexOfMonth(String month, int index) {
		Date date = parseDate(month, "yyyy-MM", "yyyy/MM", "yyyyMM");
		if (date == null)
			return null;
		return indexOfMonth(date, index);
	}

	/**
	 * 查询月份中第index天，从index从1开始
	 * 
	 * @param date
	 *            月份日期
	 * @param index
	 *            月份中天数索引
	 * @return 月份第index天
	 */
	public static Date indexOfMonth(Date date, int index) {
		Date month = date == null ? new Date() : date;
		month = trunc(date, Calendar.DATE);
		Calendar cal = toCalendar(month);
		int maxIndex = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		if (index < 0 || index > maxIndex)
			return null;
		return setDays(month, index);
	}

	/**
	 * 查询月份中倒数第index天，从index从1开始
	 * 
	 * @param month
	 *            月份字符串
	 * @param index
	 *            倒数索引
	 * @return 月份倒数第index天
	 */
	public static Date lastIndexOfMonth(String month, int index) {
		Date date = parseDate(month, "yyyy-MM", "yyyy/MM", "yyyyMM");
		if (date == null)
			return null;
		return lastIndexOfMonth(date, index);
	}

	/**
	 * 查询月份中倒数第index天，从index从1开始
	 * 
	 *            月份日期
	 * @param index
	 *            倒数索引
	 * @return 月份倒数第index天
	 */
	public static Date lastIndexOfMonth(Date date, int index) {
		Date month = date == null ? new Date() : date;
		month = trunc(date, Calendar.DATE);
		Calendar cal = toCalendar(month);
		int maxIndex = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		if (index < 0 || index > maxIndex)
			return null;
		return setDays(month, maxIndex - index + 1);
	}

	/**
	 * 遍历后或前amount天之间的所有日期
	 * 
	 * @param amount
	 * @return
	 */
	public static List<Date> iteratorDays(int amount) {
		List<Date> result = new ArrayList<Date>();
		Date today = new Date();
		int start = amount >= 0 ? 1 : amount;
		int end = amount >= 0 ? amount + 1 : 0;
		for (int i = start; i < end; i++) {
			Date date = addDays(today, i);
			result.add(date);
		}
		return result;
	}

	/**
	 * 返回开始日期和结束日期之间的所有日期
	 * 
	 * @param beginDate
	 *            开始日期
	 * @param endDate
	 *            结束日期
	 * @return
	 */
	public static List<String> iteratorDays(String beginDate, String endDate) {
		List<String> result = new ArrayList<String>();
		Date begin = getDate(beginDate, "yyyy-MM-dd");
		Date end = getDate(endDate, "yyyy-MM-dd");

		if (begin.after(end))
			return null;
		for (Date date = begin; date.before(end); date = addDays(date, 1)) {
			String str = fmtDate(date, "yyyy-MM-dd");
			result.add(str);
		}
		result.add(endDate);
		return result;
	}

	public static java.sql.Date getSQLDate(String text, String format) {
		if (text == null || "".equals(text)) {
			return null;
		}
		long time = getDate(text, format).getTime();
		return new java.sql.Date(time);
	}

	public static java.sql.Timestamp getTimestamp(Date date) {
		return new java.sql.Timestamp(date.getTime());
	}

	public static String getCurDateField(String format) {
		Date date = new Date();
		return fmtDate(date, format);
	}

	/**
	 * 获取给定月第1天
	 * 验证日期格式
	 * @param month 'yyyy-MM'
	 * @return 'yyyy-MM-dd'
	 */
	public static String getMonthFirstDay(String month) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM");
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date theDate;
		try {
			theDate = df.parse(month);
			GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
			gcLast.setTime(theDate);
			gcLast.set(Calendar.DAY_OF_MONTH, 1);
			return df1.format(gcLast.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;

	}

	/**
	 * 获取下月第1天
	 * 
	 * @return
	 */
	public static Date getNextMonthFirstDay() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.add(Calendar.MONTH, 1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		return cal.getTime();
	}
	
	/**
     * 获取给定月份下月的第1天
     * 
     * @return
     */
    public static String getNextMonthFirstDay(String month) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM");
        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(df.parse(month));
            cal.add(Calendar.MONTH, 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return df1.format(cal.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
	
	/**
	 * 获取下月最后一天
	 * 
	 * @return
	 */
	public static Date getNextMonthLastDay() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(new Date());
		cal.add(Calendar.MONTH, 1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.add(Calendar.MONTH, 1);
		cal.add(Calendar.DAY_OF_MONTH, -1);
		return cal.getTime();
	}
	
	/**
	 * 获取当月最后一天'yyyy-MM'
	 * 
	 * @param date
	 * @return 'yyyy-MM-dd'
	 * @throws ParseException
	 */
	public static String getMonthLastDay(String date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM");
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date theDate;
		try {
			theDate = df.parse(date);
			GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
			gcLast.setTime(theDate);
			gcLast.set(Calendar.DAY_OF_MONTH, 1);
			gcLast.roll(Calendar.DAY_OF_MONTH, -1);
			return df1.format(gcLast.getTime());
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取给定月份的最后一天
	 * 
	 * @param date
	 * @return
	 */
	public static Date getMonthLastDay(Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
		return c.getTime();
	}

	/**
	 * 获取指定月前一月最后一天'yyyy-MM'
	 * 
	 * @param date
	 * @return 'yyyy-MM-dd'
	 * @throws ParseException
	 */
	public static String getLastMonthMaxDay(String date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM");
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date theDate = null;
		try {
			theDate = df.parse(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
		gcLast.setTime(theDate);
		gcLast.add(Calendar.MONTH, -1);
		gcLast.set(Calendar.DAY_OF_MONTH, 1);
		gcLast.roll(Calendar.DAY_OF_MONTH, -1);
		return df1.format(gcLast.getTime());
	}

	/**
	 * 获取指定月倒数第二天'yyyy-MM'
	 * 
	 * @param date
	 * @return 'yyyy-MM-dd'
	 * @throws ParseException
	 */
	public static String getMonthLastSecondDay(String date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM");
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date theDate = null;
		try {
			theDate = df.parse(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
		gcLast.setTime(theDate);
		gcLast.set(Calendar.DAY_OF_MONTH, 1);
		gcLast.roll(Calendar.DAY_OF_MONTH, -1);
		gcLast.add(Calendar.DAY_OF_MONTH, -1);
		return df1.format(gcLast.getTime());
	}
	
	public static String compareCurrentTime(String date){
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date cur = new Date();
		try {
			Date d = df1.parse(date);
			if(d.getTime() < cur.getTime()){
				return date;
			}
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return date;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(cur);
//		cal.add(Calendar.MINUTE, -30);
		cal.add(Calendar.DAY_OF_MONTH, -1);
		String yesterday = df1.format(cal.getTime());
		return yesterday;
	}
	
	public static String getYesterday(){
		SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
		Date cur = new Date();
		Calendar cal = Calendar.getInstance();
		cal.setTime(cur);
		cal.add(Calendar.DAY_OF_MONTH, -1);
		cur = cal.getTime();
		return df1.format(cur);
	}
	
	/**
	 * 验证时间是否符合格式
	 * @param format 格式
	 * @param times  时间数组
	 * @return
	 */
	public static boolean timeNotValid(String format, String... times){
        if(null == times||times.length == 0){
            return false;
        }
        
        for (String time : times) {
            if(StringUtil.isNullOrEmpty(getDate(time,format))){
                return true;
            }
        }
        return false;
    }
	
	/**
	 * 获取时间跨度，单位分钟
	 * @param beginTime
	 * @param endTime
	 * @param pattern
	 * @return
	 */
	public static int getDateMinuteSpan(String beginTime,String endTime,String pattern){
		return getDateFieldSpan(beginTime, endTime, pattern,Calendar.MINUTE);
	}
	
	public static int getDateDaySpan(String beginTime,String endTime,String pattern){
		return getDateFieldSpan(beginTime, endTime, pattern,Calendar.DAY_OF_YEAR);
	}
	
	public static int getDateFieldSpan(String beginTime,String endTime,String pattern,int calendarType){
		return getDateFieldSpan(parseDate(beginTime, pattern), parseDate(endTime, pattern), calendarType);
	}
	
	public static int getDateFieldSpan(Date beginTime,Date endTime,int calendarType){
		long inteval = (endTime.getTime()-beginTime.getTime())/1000;
		if(calendarType == Calendar.SECOND){
			 return (int)inteval;
		}
		if(calendarType == Calendar.MINUTE){
			 return (int)inteval/60;
		}
		if(calendarType == Calendar.HOUR){
			 return (int)inteval/(60*60);
		}
		if(calendarType == Calendar.DAY_OF_YEAR){
			 return (int)inteval/(60*60*24);
		}
		return 0;
	}

	/**
	 * 时间格式化(转字符串)
	 *
	 * @param time
	 * @return
	 */
	public static String long2str(long time) {
		Date d = new Date(time);
		DateFormat df = new SimpleDateFormat(defaultFormat);
		return df.format(d);
	}

	/**
	 * 时间格式化(转字符串)
	 *
	 * @param time
	 * @return
	 */
	public static String long2strYmd(long time) {
		Date d = new Date(time);
		DateFormat df = new SimpleDateFormat(dayFormat2);
		return df.format(d);
	}

	/**
	 * 时间格式化(转 Long)
	 *
	 * @param str
	 * @return
	 */
	public static long str2long(String str) {

		Long time = null;

		DateFormat df = new SimpleDateFormat("yyyyMMdd");
		try {
			time = df.parse(str).getTime();
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return time;
	}

	/**
	 * 日期格式转换
	 * 格式：YYYY-MM-DD
	 */
	public static String fromatString(String date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date parse = sdf.parse(date);
			return sdf.format(parse).toString();
		} catch (ParseException e) {
			e.printStackTrace();
			return date;
		}
	}

	/**
	 * 日期格式转换
	 *
	 * @param date 时间字符串(格式：yyyy-MM)
	 * @return 时间字符串(格式：yyyyMM)
	 */
	public static String fromatStringyyyyMM(String date) {

		if (ObjectUtils.isObjectEmpty(date)) {
			return null;
		}
		return formatDateToMonth(date).replace("-", "");

	}

	/**
	 * 日期格式转换
	 * 格式：YYYY-MM-DD
	 */
	public static String fromatHourString(String date) {
		SimpleDateFormat sdf = new SimpleDateFormat("HH");
		try {
			Date parse = sdf.parse(date);
			return sdf.format(parse);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 日期格式转换
	 * 格式：YYYY-MM-DD
	 */
	public static int fromatToMonth(String date) {
		SimpleDateFormat sdf = new SimpleDateFormat("MM");
		try {
			Date parse = sdf.parse(date);
			return Integer.parseInt(sdf.format(parse));
		} catch (ParseException e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * YYYY-MM-DD --> date
	 * 格式：
	 */
	public static Date ymdToDate(String YMD) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date date = sdf.parse(YMD);
			return date;
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * YYYY-MM-DD --> date
	 * 格式：
	 */
	public static Date ymdhmsToDate(String yMdHms) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			Date date = sdf.parse(yMdHms);
			return date;
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获得时间戳
	 */
//    public static Timestamp newTimestamp() {
//        DateTime dateTime = new DateTime();
//        Timestamp timeStamp = new Timestamp(dateTime.getMillis());
//        return timeStamp;
//    }

	/**
	 * 获取精确到秒的时间戳
	 *
	 * @return
	 */
	public static int getSecondTimestamp() {
		Date date = new Date();
		if (null == date) {
			return 0;
		}
		String timestamp = String.valueOf(date.getTime());
		int length = timestamp.length();
		if (length > 3) {
			return Integer.valueOf(timestamp.substring(0, length - 3));
		} else {
			return 0;
		}
	}

	/**
	 * 获得日期字符串
	 * 格式：YYYY-MM-DD
	 */
	public static String newDataStr() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date data = new Date();
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期字符串
	 * 格式：yyyyMMdd
	 */
	public static String newDate() {
		return newDate("yyyyMMdd");
	}

	/**
	 * 获取日期字符串
	 * @param dateFormat 日期格式
	 * @return
	 */
	public static String newDate(String dateFormat){
		SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
		return sdf.format(new Date()).toString();
	}

	/**
	 * 获得日期字符串(当前月份第一天)
	 * 格式：YYYY-MM-DD
	 */
	public static String newDateOfMonthFirstDay() {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c = Calendar.getInstance();
		c.add(Calendar.MONTH, 0);
		c.set(Calendar.DAY_OF_MONTH, 1);//设置为1号,当前日期既为本月第一天
		return format.format(c.getTime());
	}

	/**
	 * 获得日期字符串
	 * 格式：yyyyMM
	 */
	public static String newDateOfMonth() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
		Date data = new Date();
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期字符串
	 * 格式：yyyy-MM
	 */
	public static String newDateOfMonth2() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
		Date data = new Date();
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期和时间字符串
	 * 格式：yyyy-MM-dd HH:mm:ss
	 */
	public static String newDataTimeStr() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date data = new Date();
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期和时间字符串
	 * 格式：yyyyMMddHHmmss
	 */
	public static String newDataTimeStr2() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		Date data = new Date();
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期和时间字符串
	 * 格式：yyyyMMddHHmmss
	 */
	public static String newDataTimeMill() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		Date data = new Date(System.currentTimeMillis());
		return sdf.format(data).toString();
	}

	/**
	 * 获得日期和时间字符串+4位随机数
	 * 格式：yyyyMMddHHmmss
	 */
	public static String newDataTimeMillRandom() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		Date data = new Date(System.currentTimeMillis());

		String string = sdf.format(data).toString();

		StringBuilder sb = new StringBuilder();
		sb = sb.append(string).append(NumberUtils.getRandomStr());
		return sb.toString();
	}

	/**
	 * 获得日期和时间字符串
	 * 格式：yyyyMMddHHmmss
	 */
	public static Date formatToDate(String dateStr, String format) {
		Date date = null;

		if (null == format || format.length() <= 0) {
			format = defaultFormat;
		}
		try {
			if (null != dateStr && dateStr.length() > 0) {
				date = (new SimpleDateFormat(format)).parse(dateStr);
			}
		} catch (ParseException var4) {
			var4.printStackTrace();
		}

		return date;
	}


	/**
	 * 转换Str格式成Date
	 *
	 * @param dateStr
	 * @return yyyy-MM-dd HH:mm:ss
	 */
	public static Date stringToDate(String dateStr) {
		String s = formatDateString(dateStr);
		if (s != null && s.length() > 0) {
			return formatToDate(s, "");
		}
		return null;
	}

	/**
	 * 转换Date格式成String
	 *
	 * @param date
	 * @return 2006-11-11
	 */
	public static String formatTimeToyyymmdd(Date date) {
		if (date == null) return "";
		return formatterDay.format(date);
	}

	/**
	 * 转换Date格式成String
	 *
	 * @param date
	 * @return 2006-11-11
	 */
	public static String formatTimeToString(Date date) {
		if (date == null) return "";
		return formatterYear.format(date);
	}


	/**
	 * 获得日期和时间字符串
	 *
	 * @param dateStr 格式：yyyy-MM-dd HH:mm:ss
	 * @return 格式yyyy-MM-dd HH:mm:ss
	 */
	public static String formatDateString(String dateStr) {

		if (ValidatorUtils.isEmpty(dateStr)) {
			return "";
		}

		HashMap<String, String> dateRegFormat = new HashMap<String, String>();
		dateRegFormat.put("^\\d{4}\\D+\\d{1,2}\\D+\\d{1,2}\\D*$",
				"yyyy-MM-dd");
		dateRegFormat.put("^\\d{4}\\D+\\d{1,2}\\D*$",
				"yyyy-MM");
		dateRegFormat.put("^\\d{4}\\D+\\d{1,2}\\D+\\d{1,2}\\D+\\d{1,2}\\D+\\d{1,2}\\D+\\d{1,2}\\D*$",
				"yyyy-MM-dd-HH-mm-ss");// 2016年3月12日 13时5分34秒，2016-03-12
		// 12:05:34，2016/3/12 12:5:34
		dateRegFormat.put("^\\d{8}$", "yyyyMMdd");// 20160312
		dateRegFormat.put("^\\d{6}$", "yyyyMM");// 201603
		dateRegFormat.put("^\\d{2}\\s*:\\s*\\d{2}$", "yyyy-MM-dd-HH-mm");// 13:05
		dateRegFormat.put("^\\d{14}$", "yyyyMMddHHmmss");// 20170315143235
		// 拼接当前日期
		String curDate = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
		DateFormat formatter1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		DateFormat formatter2;
		String dateReplace;
		String strSuccess = "";
		try {
			for (String key : dateRegFormat.keySet()) {
				if (Pattern.compile(key).matcher(dateStr).matches()) {
					formatter2 = new SimpleDateFormat(dateRegFormat.get(key));
					if (key.equals("^\\d{2}\\s*:\\s*\\d{2}\\s*:\\s*\\d{2}$") || key.equals("^\\d{2}\\s*:\\s*\\d{2}$")) {// 13:05:34
						// 或
						// 13:05
						// 拼接当前日期
						dateStr = curDate + "-" + dateStr;
					}
					dateReplace = dateStr.replaceAll("\\D+", "-");
					strSuccess = formatter1.format(formatter2.parse(dateReplace));
					break;
				}
			}
		} catch (ParseException var4) {
			var4.printStackTrace();
		} finally {
			return strSuccess;
		}
	}

	/**
	 * 获得时间(int)
	 *
	 * @param dateStr 格式：yyyy-MM-dd
	 * @return yyyy-MM-dd
	 */
	public static Integer formatToInteger(String dateStr) {
		StringBuilder sb = new StringBuilder();
		if (!ValidatorUtils.isNull(dateStr) && dateStr.length() == 10) {
			sb.append(dateStr.substring(0, 4));
			sb.append(dateStr.substring(5, 7));
			sb.append(dateStr.substring(8));
			dateStr = sb.toString();
			int i = Integer.parseInt(dateStr);
			return i;
		}
		return null;
	}

	/**
	 * 获得时间字符串
	 *
	 * @param dateStr 格式：yyyyMMddDDmmss
	 * @return yyyy-MM-dd
	 */
	public static String format(String dateStr) {
		StringBuilder sb = new StringBuilder();
		if (ValidatorUtils.isNull(dateStr)) {
			return null;
		}
		if (dateStr != null && 6 <= dateStr.length() && dateStr.length() < 8) {
			sb.append(dateStr.substring(0, 4));
			sb.append("-");
			sb.append(dateStr.substring(4, 6));
			return String.valueOf(sb);
		}
		if (dateStr != null && dateStr.length() >= 8) {
			sb.append(dateStr.substring(0, 4));
			sb.append("-");
			sb.append(dateStr.substring(4, 6));
			sb.append("-");
			sb.append(dateStr.substring(6, 8));
			return String.valueOf(sb);
		}
		return null;
	}

	/**
	 * 返回n天之后的日期
	 */
	public static Date getDateLater(Date now, int n) {
		return new Date(now.getTime() + oneDay * n);
	}

	/**
	 * 获取 N 天后(n>0)或者 N 天前(n<0)的日期  返回格式 YYYY-MM
	 */
	public static String getMonthLater(String strDate, int n) {
		strDate = formatDateString(strDate);
		Date date = ymdToDate(strDate);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MONTH, n);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
		String dateStr = sdf.format(calendar.getTime());

		return dateStr;
	}

	/**
	 * 获取 N 天后(n>0)或者 N 天前(n<0)的日期  返回格式 YYYY-MM-dd
	 */
	public static String getMonthLaterYYYYMMdd(int n) {

		String dateNow = newDataStr();
		dateNow = formatDateString(dateNow);
		Date date = ymdToDate(dateNow);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, n);
		SimpleDateFormat sdf = new SimpleDateFormat(dayFormat2);

		return sdf.format(calendar.getTime());
	}

	/**
	 * 获取输入日期 N 天后(n>0)或者 N 天前(n<0)的日期  返回格式 YYYY-MM-dd
	 *
	 * @param dateStr 起始日期
	 * @param n       天数
	 * @return 处理过的时间
	 */
	public static String getMonthLaterYYYYMMdd(String dateStr, int n) {

		String dateNow = dateStr;
		dateNow = formatDateString(dateNow);
		Date date = ymdToDate(dateNow);
		if (!ObjectUtils.isObjectEmpty(date)) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.add(Calendar.DAY_OF_MONTH, n);
			SimpleDateFormat sdf = new SimpleDateFormat(dayFormat2);
			return sdf.format(calendar.getTime());
		}

		return null;
	}

	/**
	 * 根据年月 算天数
	 */
	public static int getDayOfMonth(String yearMonth) {

		if (null == yearMonth || yearMonth.length() < 0) {
			return 0;
		}
		// 1.使用Calendar日期函数(声明)
		Calendar calendar = new GregorianCalendar();
		// 或者用Calendar calendar = Calendar.getInstance();

		// 格式化日期--设置date
		SimpleDateFormat sdf = new SimpleDateFormat("", Locale.ENGLISH);
		sdf.applyPattern("yyyy-MM"); // 201203格式

		String date = yearMonth;// 日期格式

		try {
			System.out.println(sdf.parse(date));
			calendar.setTime(sdf.parse(date));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		/** 开始用的这个方法获取实际月的最大天数* */
		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 常规时间转月份
	 *
	 * @param date 时间(yyyy-MM-dd HH:ss:mm)
	 * @return 时间月份(yyyy-MM)
	 */
	public static String formatDateToMonth(String date) {

		if (ValidatorUtils.isEmpty(date)) {
			return null;
		}

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");

		try {
			Date parse = sdf.parse(date);
			return sdf.format(parse).toString();
		} catch (ParseException e) {
			return date;
		}
	}

	/**
	 * 日期格式转换
	 * 格式：YYYY-MM-DD
	 */
	public static String formatStringToDay(String date) {
		if (ValidatorUtils.isEmpty(date)) {
			return null;
		}
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date parse = sdf.parse(date);
			return sdf.format(parse).toString();
		} catch (ParseException e) {
			e.printStackTrace();
			return date;
		}
	}

	/**
	 * 将时间分割成日期和时间数组
	 *
	 * @param startTime 时间 格式必须为：yyyy-MM-dd HH:mm:ss
	 * @return 日期时间数组
	 */
	public static String[] splitStartTime(String startTime) {

		if (ValidatorUtils.isEmpty(startTime)) {
			return new String[2];
		}

		try {
			String[] split = startTime.split(" ");
			return split;
		} catch (Exception e) {
			e.printStackTrace();
			return new String[2];
		}
	}

	/**
	 * 秒转分
	 *
	 * @param useTime 秒(Float 类型)
	 * @return 分
	 */
	public static BigDecimal timeHToSecond(Float useTime) {

		String time = NumberUtils.floatToString(useTime);

		if (ValidatorUtils.isEmpty(time)) {
			return null;
		}

		BigDecimal divide = new BigDecimal(time).divide(new BigDecimal("60"), 2, RoundingMode.HALF_UP);

		return divide;
	}

	/**
	 * 秒转分
	 *
	 * @param days 天
	 * @return month
	 */
	public static Integer dayToMonth(String days) {

		if (ValidatorUtils.isEmpty(days)) {
			return null;
		}

		BigDecimal divide = new BigDecimal(days).divide(new BigDecimal("30"), 0, RoundingMode.HALF_UP);

		if (divide.compareTo(new BigDecimal(0)) <= 0) {
			return 1;
		}

		return Integer.parseInt(divide.toString());
	}

	/**
	 * 获得日期字符串
	 *
	 * @param dateStr 格式：yyyy-MM-dd HH:mm:ss
	 * @return yyyy-MM-dd
	 */
	public static String getBirthDateStr(String dateStr) {

		if (ValidatorUtils.isEmpty(dateStr)) {
			return "";
		}

		return dateStr.substring(0, 10);
	}


	/**
	 * 获得日期字符串
	 *
	 * @param dateStr 格式：yyyy-MM-dd HH:mm:ss
	 * @return yyyy-MM-dd
	 */
	public static String getYear(String dateStr) {

		if (ValidatorUtils.isEmpty(dateStr)) {
			return "";
		}

		return dateStr.substring(0, 4);
	}

	/**
	 * 算相差天数
	 *
	 * @param date1 时间1
	 * @param date2 时间2
	 * @return 相差天数
	 */
	public static int getDays(Date date1, Date date2) {

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

		String strDate1 = sdf.format(date1);
		String strDate2 = sdf.format(date2);

		long longDate1 = stringToDate(strDate1).getTime();
		long longDate2 = stringToDate(strDate2).getTime();

		return (int) ((longDate1 - longDate2) / (1000 * 60 * 60 * 24));
	}

	/**
	 * 计算相差天数
	 *
	 * @param beginDateStr 开始日期
	 * @param endDateStr   结束日期
	 * @return 相差天数
	 */
	public static long getDaySub(String beginDateStr, String endDateStr) {
		long day = 0;
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date beginDate;
		Date endDate;
		try {
			beginDate = format.parse(beginDateStr);
			endDate = format.parse(endDateStr);
			day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
			//System.out.println("相隔的天数="+day);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return day;
	}

	/**
	 * 计算相差月数
	 *
	 * @param beginDateStr 开始日期
	 * @param endDateStr   结束日期
	 * @return 相差天数
	 */
	public static long getMonthSub(String beginDateStr, String endDateStr) {
		long day = 0;
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
		Date beginDate;
		Date endDate;
		try {
			beginDate = format.parse(beginDateStr);
			endDate = format.parse(endDateStr);
			day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
			//System.out.println("相隔的天数="+day);
			return day / 30;
		} catch (ParseException e) {
			e.printStackTrace();
			return day;
		}
	}

	/**
	 * 计算List<String>时间集合中最大日期
	 *
	 * @param ins 时间集合(格式：yyyy-MM-dd)
	 * @return 最大时间
	 */
	public static String getMaxDate(List<String> ins) {

		String a = null;
		if (!ObjectUtils.isObjectEmpty(ins)) {

			for (int i = 0; i < ins.size(); i++) {
				if (i == 0) {
					a = ins.get(i);
				}
				if (ins.get(i).compareTo(a) > 0) {
					a = ins.get(i);
				}
			}
		}
		return a;
	}

	/**
	 * 计算List<String>时间集合中最小日期
	 *
	 * @param ins 时间集合(格式：yyyy-MM-dd)
	 * @return 最大时间
	 */
	public static String getMinDate(List<String> ins) {

		String a = null;
		if (!ObjectUtils.isObjectEmpty(ins)) {

			for (int i = 0; i < ins.size(); i++) {
				if (i == 0) {
					a = ins.get(i);
				}
				if (ins.get(i).compareTo(a) < 0) {
					a = ins.get(i);
				}
			}
		}
		return a;
	}
}
